/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "UI.h"
#include <UI/布局.h>
#include "ui绘制模板.h"


static float32 g_部件小距离偏移 = 1;



void f_ui绘制模板_图标绘制(S_2D画布* s, S_图标绘制ID& id, uint16 属性ID, std::string 图标集) {
	id.id_变换 = f_buf_alloc(S_2D画布::g图标变换, 1);
	id.id_颜色 = f_buf_alloc(S_2D画布::g图标颜色, 1);
	id.层ID    = f_vg_画图标(s, 属性ID, 图标集);
}

void f_ui绘制模板_单色图标绘制(S_2D画布* s, S_图标绘制ID& id, uint16 属性ID, std::string 图标集) {
	id.id_变换 = f_buf_alloc(S_2D画布::g图标变换, 1);
	id.id_颜色 = f_buf_alloc(S_2D画布::g图标颜色, 1);
	id.层ID    = f_vg_画单色图标(s, 属性ID, 图标集);
}

void f_ui绘制模板_动态线(S_2D画布* s, S_图标绘制ID& ID, uint16 属性ID, float32 lw) {
	ID.id_变换 = f_buf_alloc(S_2D画布::g图标变换, 1);
	ID.id_颜色 = f_buf_alloc(S_2D画布::g图标颜色, 1);
	ID.层ID = f_vg_画动态线(s, 属性ID, lw);
}

void f_ui绘制模板_画行文本(S_2D画布* s, S_行文本绘制ID& 文本ID, uint16 属性ID, uint16 字号) {
	文本ID.id_变换 = f_buf_alloc(s->g行文本变换GPU缓存, 0);
	文本ID.id_颜色 = f_buf_alloc(s->g行文本颜色GPU缓存, 0);
	文本ID.id_文本 = f_buf_alloc(s->g字符GPU缓存, 0);

	文本ID.层ID = f_vg_画行文本(s, s->g字符GPU缓存, s->g行文本变换GPU缓存, s->g行文本颜色GPU缓存, 属性ID, 字号, S_UI主题::ui_默认字体);
}



bool f_ui绘制模板_重置凸矩形数量(S_2D画布* 画布, S_单色绘制ID& id, uint32 num) {
	bool GPU参数重新配置 = false;

	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_图元, num);
	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_变换, num);
	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_颜色, num);

	return GPU参数重新配置;
}

static bool f_ui绘制模板_重置凸矩形数量(S_2D画布* 画布, S_单色边面ID& id, uint32 num) {
	bool GPU参数重新配置 = false;

	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_图元, num);
	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_变换, num);
	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_面颜色, num);
	GPU参数重新配置 |= f_vg_resize参数实例(画布, id.id_边颜色, num);

	f_vg_set实例数量(画布, id.id_边元素, num);
	f_vg_set实例数量(画布, id.id_面元素, num);

	return GPU参数重新配置;
}





ui_绘制模板_Vec::ui_绘制模板_Vec() {

}

void ui_绘制模板_Vec::f_Layout(C_Widget* w) {
	auto e = w->mf_get更新组件(w);

	float32 h = w->m_Size.y / e.m_Num;

	vec2 pos = { 0, 0 };
	vec2 size = { w->m_Size.x , h };

	
	for (uint8 i = 0; i < e.m_Num; ++i) {
		pos.y = h * i;
		e.m_W[i]->f_setPos(pos);
		e.m_W[i]->f_setSize(size);
	}

}





ui_绘制模板_行文本绘制::ui_绘制模板_行文本绘制(uint16 单行字符最大数量) : m_字体(nullptr) {
	m_画布 = nullptr;
	m_文本.id_变换 = {};
	m_文本.id_文本 = {};
	m_文本.id_颜色 = {};
}
ui_绘制模板_行文本绘制::~ui_绘制模板_行文本绘制() {
	if(m_文本.id_变换.m_Buf) f_buf_erase(m_文本.id_变换);
	if(m_文本.id_文本.m_Buf) f_buf_erase(m_文本.id_文本);
	if(m_文本.id_颜色.m_Buf) f_buf_erase(m_文本.id_颜色);
}

void ui_绘制模板_行文本绘制::f_Draw(S_2D画布* 画布, const S_Font* 字体, uint16 属性ID) {
	//return;
	m_画布 = 画布;
	m_字体 = 字体;
	f_ui绘制模板_画行文本(画布, m_文本, 属性ID, m_字体->m_字号);

	m_字体 = &f_surface_get字体(画布, S_UI主题::ui_默认字体, m_字体->m_字号);

	auto& 层 = m_画布->m_surf[m_文本.层ID];
	层.m_顶点数量 = 1;
}

void ui_绘制模板_行文本绘制::f_alloc(uint32 变换num, uint32 所有字符num) {
	//return;
	m_单行字符最大数量 = 所有字符num;
	//assert(变换num);
	if(!变换num) {
		m_画布->m_surf[m_文本.层ID].m_实例数量 = 变换num;
		m_画布->m_surf[m_文本.层ID].m_实例偏移 = m_文本.id_变换.m_Mem.m_偏移;
		return;
	}

	f_buf_gresize(m_文本.id_变换, 变换num);
	f_buf_gresize(m_文本.id_颜色, 变换num);
	f_buf_gresize(m_文本.id_文本, 变换num * m_单行字符最大数量);

	f_vg_set实例数量(m_画布, m_文本.层ID, 变换num);

	m_Prt.coord = f_buf_Mat3X2_ptr(m_文本.id_变换);
	m_Prt.color = f_buf_UI32_ptr(m_文本.id_颜色);
	m_Prt.text = f_buf_I32_ptr(m_文本.id_文本);
	
	m_画布->m_surf[m_文本.层ID].m_实例数量 = 变换num;
	m_画布->m_surf[m_文本.层ID].m_实例偏移 = m_文本.id_变换.m_Mem.m_偏移;

	return;
}

void ui_绘制模板_行文本绘制::f_设置文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt) {
	txt = txt.substr(0, DEF_Min(txt.size(), m_单行字符最大数量));

	txt = f_vg_set行文本(m_画布, m_文本.层ID, txt, 变换GPU偏移 * m_单行字符最大数量, rect.extent.x, m_Prt.text);
	assert(txt.size() <= m_单行字符最大数量);
	m_Prt.coord[变换GPU偏移].row0 = rect.offset;
	m_Prt.coord[变换GPU偏移].row1.x = rect.extent.x;
	m_Prt.coord[变换GPU偏移].row1.y = txt.size();
	m_Prt.coord[变换GPU偏移].row2.x = 变换GPU偏移 * m_单行字符最大数量 + m_文本.id_文本.m_Mem.m_偏移;

	m_Prt.color[变换GPU偏移] = f_PackData4X8(color);
}

void ui_绘制模板_行文本绘制::f_居中绘制文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt) {
	txt = txt.substr(0, DEF_Min(txt.size(), m_单行字符最大数量));

	float32 文本宽度 = rect.extent.x * 1.01;
	txt = f_vg_set行文本(m_画布, m_文本.层ID, txt, 变换GPU偏移 * m_单行字符最大数量, 文本宽度, m_Prt.text);
	vec2 居中偏移 = f_widget_get文字绘制据中偏移(rect.extent, txt, *m_字体, 2);
	assert(txt.size() <= m_单行字符最大数量);
	m_Prt.coord[变换GPU偏移].row0 = rect.offset + 居中偏移;
	m_Prt.coord[变换GPU偏移].row1.x = rect.extent.x;
	m_Prt.coord[变换GPU偏移].row1.y = txt.size();
	m_Prt.coord[变换GPU偏移].row2.x = 变换GPU偏移 * m_单行字符最大数量 + m_文本.id_文本.m_Mem.m_偏移;

	m_Prt.color[变换GPU偏移] = f_PackData4X8(color);
}

void ui_绘制模板_行文本绘制::f_绘制文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt, E_对齐方式 方式, float32 缩放) {
	txt = txt.substr(0, DEF_Min(txt.size(), m_单行字符最大数量));

	txt = f_vg_set行文本(m_画布, m_文本.层ID, txt, 变换GPU偏移 * m_单行字符最大数量, rect.extent.x * 缩放, m_Prt.text);
	vec2 居中偏移 = { 0, float32(m_字体->m_字号 * -0.2) };
	assert(txt.size() <= m_单行字符最大数量);
	switch (方式) {
	case E_对齐方式::e_左对齐:
		//居中偏移.y = rect.extent.y * 0.5 + m_字体->m_字号 * 0.5 / (DEF_Min(缩放, 1));
		居中偏移.y = rect.extent.y * 0.5 - (m_字体->m_字号+1) * 0.5 / 缩放;
		//居中偏移.y = 0 ;
		break;
	case E_对齐方式::e_右对齐:
		居中偏移.x = f_surface_get字符串宽度(*m_字体, txt, 2) / 缩放;
		居中偏移.x = rect.extent.x - 居中偏移.x;
		break;
	case E_对齐方式::e_据中对齐:
		居中偏移.x = f_surface_get字符串宽度(*m_字体, txt, 2);
		居中偏移.x = rect.extent.x * 0.5 - 居中偏移.x * 0.5 / 缩放;
		居中偏移.y = rect.extent.y*0.5 - (m_字体->m_字号+2) * 0.5 / 缩放;
		break;
	}

	m_Prt.coord[变换GPU偏移].row0 = rect.offset + 居中偏移;
	m_Prt.coord[变换GPU偏移].row1.x = rect.extent.x;
	m_Prt.coord[变换GPU偏移].row1.y = txt.size();
	m_Prt.coord[变换GPU偏移].row2.x = 变换GPU偏移 * m_单行字符最大数量 + m_文本.id_文本.m_Mem.m_偏移;
	m_Prt.coord[变换GPU偏移].row2.y = 缩放;

	m_Prt.color[变换GPU偏移] = f_PackData4X8(color);
}


void ui_绘制模板_行文本绘制::f_绘制刻度数字(S_Rect2Df & rect, uint32 num, vec2 开始_步进, float32 间隔) {
	//return;
	for (uint32 i = 0; i < num; ++i) {
		auto txt = f_整数值转宽字符串64(开始_步进.x);

		txt = f_vg_set行文本(m_画布, m_文本.层ID, txt, i*m_单行字符最大数量, rect.extent.x, m_Prt.text);


		m_Prt.coord[i].row0 = rect.offset;
		m_Prt.coord[i].row1.x = rect.extent.x;
		m_Prt.coord[i].row1.y = txt.size();
		m_Prt.coord[i].row2.x = m_单行字符最大数量 * i + m_文本.id_文本.m_Mem.m_偏移;

		m_Prt.color[i] = f_PackData4X8(S_UI主题::uic_文字颜色);
		
		开始_步进.x += 开始_步进.y;
		rect.offset.x += 间隔;
	}
}

void ui_绘制模板_行文本绘制::f_Close(S_2D画布* 画布) {
	//return;
	f_vg_set实例数量(画布, m_文本.层ID, 0);
}

void ui_绘制模板_行文本绘制::f_Close(uint32 num) {
	//return;
	if(m_画布) f_vg_set实例数量(m_画布, m_文本.层ID, num);
}









ui_绘制模板_编辑框编辑状态::ui_绘制模板_编辑框编辑状态() {

}

void ui_绘制模板_编辑框编辑状态::f_Draw点(S_2D画布* 画布, uint16 属性ID, uint16 字号) {
	m_字号 = 字号;

	//=================== 当前编辑背景 ===================
	//f_ui绘制模板_无边圆角矩形(画布, m_背景ID.id_变换, m_背景ID.id_颜色, m_背景ID.id_元素, 属性ID);
	f_vg_set单色(画布, m_背景ID.id_颜色, 0, S_UI主题::uic_数值编辑框开启编辑背景);

	//=================== 编辑文本选框 =========
	//f_ui绘制模板_无边圆角矩形(画布, m_选取ID.id_变换, m_选取ID.id_颜色, m_选取ID.id_元素, 属性ID);
	f_vg_set单色(画布, m_选取ID.id_颜色, 0, S_UI主题::uic_行编辑框选框);

	//f_ui绘制模板_编辑文本(画布, m_编辑文本.id_文本,
	//	m_编辑文本.id_变换,
	//	m_编辑文本.id_颜色,
	//	m_编辑文本.id_元素,
	//	属性ID,
	//	m_编辑文本对象,
	//	字号
	//);
}

void ui_绘制模板_编辑框编辑状态::f_开启编辑(S_2D画布* 画布, C_Widget* w, const S_Font& 字体) {
	C_文本框* editBox = dynamic_cast<C_文本框*>(w);

	std::wstring 完成文字;// = f_ui_get数值部件文本(w, true);
	if (f_ui_编辑框开关编辑(w, true)) {
		mat3X2 editBoxMat;

		editBoxMat.row0 = f_ui_行编辑框光标位置(w) + g_部件小距离偏移;
		editBoxMat.row1 = w->m_Size;
		editBoxMat.row2 = { 1, 0 };
		f_vg_set变换(画布, m_光标ID.id_变换, 0, editBoxMat);

		f_vg_set实例数量(画布, m_光标ID.id_元素, 1);
		f_vg_set实例数量(画布, m_选取ID.id_元素, 0);
	}
	else {
		f_ui_set行文本框文本(w, 完成文字);
		f_widget_选择编辑文本(editBox, { 0, uint32(-1) });
		f_vg_set实例数量(画布, m_光标ID.id_元素, 0);

		mat3X2 editBoxMat;
		editBoxMat.row0 = editBox->m_Pos + vec2{ editBox->m_行选框左边和右边.x, 0 } + g_部件小距离偏移;
		editBoxMat.row1 = vec2{ editBox->m_行选框左边和右边.y - editBox->m_行选框左边和右边.x, w->m_Size.y };
		editBoxMat.row2 = { 1, 0 };
		f_vg_set变换(画布, m_选取ID.id_变换, 0, editBoxMat);
		f_vg_set实例数量(画布, m_选取ID.id_元素, 1);


		
		vec2 居中偏移 = f_widget_get文字绘制据中偏移(C_文本框::g当前操作文本框, 完成文字, 字体, S_UI主题::ui_文字间隔);
		editBoxMat.row0 = C_文本框::g当前操作文本框->m_Pos + 居中偏移;
		editBoxMat.row1 = { w->m_Size.x, float32(完成文字.size()) };
		editBoxMat.row2 = { 0, 0 };

		f_vg_set变换(画布, m_编辑文本.id_变换, 0, editBoxMat);
		f_vg_set单色(画布, m_编辑文本.id_颜色, 0, S_UI主题::uic_文字颜色);


		//f_vg_set文本(画布, m_编辑文本对象, 0, 完成文字);
		f_vg_set实例数量(画布, m_编辑文本.id_元素, 1);
	}




	mat3X2 editBoxMat = { w->m_Pos, w->m_Size, {S_UI主题::ui_面板圆角半径, 0} };
	f_vg_set变换(画布, m_背景ID.id_变换, 0, editBoxMat);
	f_vg_set实例数量(画布, m_背景ID.id_元素, 1);


	
	//f_vg_set实例数量(画布, m_编辑文本.id_元素, 完成文字.size());

}

void ui_绘制模板_编辑框编辑状态::f_当前输入(S_2D画布* 画布, C_Widget& w, const S_Font& 字体, std::wstring& text) {
	uint8 分量 = w.m_实例ID;
	//auto e = w.mf_get更新组件(&w);
	//C_Widget* editbox = w.m_父部件;

	//f_vg_set文本(画布, m_编辑文本对象, 0, text);

	vec2 居中偏移 = f_widget_get文字绘制据中偏移(&w, text, 字体, 2);
	mat3X2 editBoxMat;
	editBoxMat.row0 = w.m_父部件->m_Pos + w.m_Pos + 居中偏移;
	editBoxMat.row1 = { w.m_Size.x, float32(text.size()) };
	editBoxMat.row2 = { 0, 0 };
	f_vg_set变换(画布, m_编辑文本.id_变换, 0, editBoxMat);
	f_vg_set实例数量(画布, m_编辑文本.id_元素, text.size());


	f_vg_set实例数量(画布, m_选取ID.id_元素, 0);
	editBoxMat.row0 = f_ui_行编辑框光标位置(&w) + g_部件小距离偏移;
	editBoxMat.row1 = w.m_Size;
	editBoxMat.row2 = { 1, 0 };
	f_vg_set变换(画布, m_光标ID.id_变换, 0, editBoxMat);
}

void ui_绘制模板_编辑框编辑状态::f_输入完成(S_2D画布* 画布) {
	f_vg_set实例数量(画布, m_背景ID.id_元素, 0);
	f_vg_set实例数量(画布, m_选取ID.id_元素, 0);
	f_vg_set实例数量(画布, m_光标ID.id_元素, 0);
	f_vg_set实例数量(画布, m_编辑文本.id_元素, 0);
	std::cout << "vec 输入完成" << std::endl;
}



void ui_绘制模板_编辑框编辑状态::f_框选(S_2D画布* 画布, C_文本框* box)
{
	mat3X2 editBoxMat;
	editBoxMat.row0 = box->m_Pos + vec2{ box->m_行选框左边和右边.x, 0 };
	editBoxMat.row1 = vec2{ box->m_行选框左边和右边.y - box->m_行选框左边和右边.x, box->m_Size.y };
	editBoxMat.row2 = { 1, 0 };
	f_vg_set变换(画布, m_选取ID.id_变换, 0, editBoxMat);
	f_vg_set实例数量(画布, m_选取ID.id_元素, 1);
	std::cout << "f_框选: " << box->m_行选框左边和右边.x << " : " << box->m_行选框左边和右边.y << std::endl;
}

void ui_绘制模板_编辑框编辑状态::f_GPU参数修改(S_2D画布* 画布, C_文本框& w) {
	mat3X2 mat;

	if (w.m_行选框左边和右边.y - w.m_行选框左边和右边.x > 1) {
		//============= 选框更新 =============
		//mat.row0 = w.m_Pos + vec2{ w.m_选框.x, 0 } + w.m_父部件->m_Pos;
		//std::cout << "w.m_选框.x:" << w.m_选框.x << "  w.m_选框.y:" << w.m_选框.y << std::endl;
		mat.row0 = w.m_Pos + vec2{ w.m_行选框左边和右边.x, 0 };
		mat.row1 = vec2{ w.m_行选框左边和右边.y - w.m_行选框左边和右边.x, w.m_Size.y };
		mat.row2 = { 1, 0 };
		f_vg_set变换(画布, m_选取ID.id_变换, 0, mat);
		f_vg_set实例数量(画布, m_选取ID.id_元素, 1);

	}
	else {
		f_vg_set实例数量(画布, m_选取ID.id_元素, 0);
	}

	//============ 光标更新 ==============
	//mat.row0 = f_ui_行编辑框光标位置(&w) + w.m_父部件->m_Pos;
	mat.row0 = f_ui_行编辑框光标位置(&w) + g_部件小距离偏移;
	mat.row1 = w.m_Size;
	mat.row2 = { 1, 0 };
	f_vg_set变换(画布, m_光标ID.id_变换, 0, mat);
}











ui_绘制模板_画预设图形::ui_绘制模板_画预设图形() {
	m_属性 = 0;
	m_图元 = {};
	//m_间接Ptr = {};
	m_画布 = nullptr;
}

ui_绘制模板_画预设图形::~ui_绘制模板_画预设图形() {
	//if(!m_图元.链接属性);
	if(!m_图元.链接变换 && m_图元.变换) f_buf_erase(*m_图元.变换);
	if(!m_图元.链接颜色 && m_图元.颜色) f_buf_erase(*m_图元.颜色);
	if(!m_图元.链接线属性 && m_图元.线属性) f_buf_erase(*m_图元.线属性);
	if(!m_图元.链接纹理属性 && m_图元.纹理属性) f_buf_erase(*m_图元.纹理属性);
}

void ui_绘制模板_画预设图形::f_Draw(S_2D画布* 画布, const S_凸边图元& 链接参数, E_笔刷类型 笔刷, float32 线宽) {
	m_画布 = 画布;
	
	E_填充模式 填充模式;
	switch (笔刷) {
	case e_单色填充:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填充面;
		goto To_绘制单色面线;
	case e_单色描边:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填充线;
		goto To_绘制单色面线;
	case e_单色边面:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填边面;
		goto To_绘制单色边面;
	case e_条纹:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		//m_图元 = f_vg_gen凸边纹理图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填充面;
		goto To_绘制纹理面线;
	case e_单色纹理:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		//m_图元 = f_vg_gen凸边纹理图元(m_画布, 链接参数);
		goto To_绘制纹理面线;

	case e_纹理:
		//m_图元 = f_vg_gen纹理图元(m_画布, 链接参数);
		//f_vg_画纹理(m_画布, m_图元, nullptr);
		return;
		
	case E_笔刷类型::e_渐变:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		f_vg_画渐变(m_画布, m_图元);
		return;

	case e_色轮:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		f_vg_画色轮(m_画布, m_图元);
		return;
		
	case E_笔刷类型::e_噪波:
		//m_图元 = f_vg_gen纹理图元(m_画布, 链接参数);
		//m_层ID = f_vg_画噪波(m_画布, m_图元);
		return;
	}

To_绘制单色面线:
	f_vg_画间接凸边形(m_画布, m_图元, 填充模式);
	return;

To_绘制纹理面线:
	f_vg_画条纹纹理(m_画布, m_图元, 填充模式);
	return;

To_绘制单色边面:
	return;

}

void ui_绘制模板_画预设图形::f_alloc(uint32 num) {
	f_ui绘制模板_间接内存resize(m_画布, m_图元, num);
	
	auto& 层 = m_画布->m_surf[m_图元.层];

	层.m_顶点数量 = 层.m_顶点.m_Mem.m_大小;
	层.m_顶点偏移 = 层.m_顶点.m_Mem.m_偏移;

	层.m_实例数量 = num;
	层.m_实例偏移 = m_图元.变换->m_Mem.m_偏移;
}


void ui_绘制模板_画预设图形::f_setColor(uint32 id, const S_RGBA8UI& C) {
	if(!m_画布) return;
	
	if (id >= m_图元.颜色->m_Mem.m_大小) {
		std::cout<<"画预设图形::f_setColor = "<<id<<" :"<< m_图元.颜色->m_Mem.m_大小<<std::endl;
		return;
	}

	assert(id < m_图元.颜色->m_Mem.m_大小);
	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8(C);
	//m_间接Ptr.p颜色[id] = f_PackData4X8(C);
	//std::cout<<"m_间接Ptr.p颜色 = " << m_间接Ptr.p颜色 << " : " << m_图元.颜色->m_Mem.m_大小 <<" : " << id << std::endl;
}

void ui_绘制模板_画预设图形::f_绘制滚动条(uint32 id, C_Widget* 滚动条) {
	assert(id < m_图元.变换->m_Mem.m_大小);
	assert(id < m_图元.颜色->m_Mem.m_大小);
	assert(id < m_图元.线属性->m_Mem.m_大小);

	mat3X2 mat;
	mat.row0 = 滚动条->m_Pos;
	mat.row1 = 滚动条->m_Size;
	mat.row2 = { 3, 0 };

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8(滚动条->m_颜色A);
	//m_间接Ptr.p变换[id] = mat;
	//m_间接Ptr.p颜色[id] = f_PackData4X8(滚动条->m_颜色A);
	//m_间接Ptr.p间接[id] = { S_Widget预设图元::m_圆角矩形.y - S_Widget预设图元::m_圆角矩形.x, 1, S_Widget预设图元::m_圆角矩形.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	auto& 区间 = m_画布->m_surf[m_图元.层].m_间接;
	f_buf_at_Indirect(区间, id) = { S_Widget预设图元::m_圆角矩形.y - S_Widget预设图元::m_圆角矩形.x, 1, S_Widget预设图元::m_圆角矩形.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };

}

uint32 ui_绘制模板_画预设图形::f_fill顶点(vec2* 顶点, uint32 num) {
	auto& 层 = m_画布->m_surf[m_图元.层];
	f_buf_gresize(层.m_顶点, num);
	//S_2D图元顶点* vert = f_buf_图元顶点_ptr(m_画布->m_surf[m_图元.层].m_顶点);
	for (uint32 i = 0; i < num; ++i) {
		f_buf_图元顶点_at(层.m_顶点, i) = {顶点[i], {1,1}, {1,1}};
		//vert[i].coord = 顶点[i];
		//vert[i].normal = {};
		//vert[i].weights = { 1,1 };
		assert(i < 层.m_顶点.m_Mem.m_大小);
	}
	
	m_画布->m_surf[m_图元.层].m_顶点数量 = num;
	m_画布->m_surf[m_图元.层].m_顶点偏移 = m_画布->m_surf[m_图元.层].m_顶点.m_Mem.m_偏移;
	return m_画布->m_surf[m_图元.层].m_顶点偏移;
}

void ui_绘制模板_画预设图形::f_set单色填充(uint32 id, const mat3X2& mat, const S_RGBA8UI& C, const uvec2& 图元ID, float32 线宽) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	assert(id < m_图元.变换->m_Mem.m_大小);
	assert(id < m_图元.颜色->m_Mem.m_大小);
	assert(id < m_图元.线属性->m_Mem.m_大小);

	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8(C);
	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	
	auto& 区间 = m_画布->m_surf[m_图元.层].m_间接;
	f_buf_at_Indirect(区间, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };

	//m_间接Ptr.p变换[id] = mat;
	//m_间接Ptr.p颜色[id] = f_PackData4X8(C);
	//m_间接Ptr.p间接[id] = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };

	层.m_线宽 = 线宽;
}

void ui_绘制模板_画预设图形::f_set单色线(uint32 id, const mat3X2& mat, const S_LineProp& C, const uvec2& 图元ID, float32 线宽) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	assert(id < m_图元.变换->m_Mem.m_大小);
	assert(id < m_图元.颜色->m_Mem.m_大小);
	assert(id < m_图元.线属性->m_Mem.m_大小);

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8({ 255,255,0,255 });
	f_buf_线属性_at(*m_图元.线属性, id) = C;
	f_buf_at_Indirect(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	//m_间接Ptr.p变换[id] = mat;
	//m_间接Ptr.p颜色[id] = f_PackData4X8({255,255,0,255});
	//m_间接Ptr.p间接[id] = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	//f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8({255,255,0,255});
	
	层.m_线宽 = 线宽;
	
}

void ui_绘制模板_画预设图形::f_set色轮(uint32 id, const mat3X2& mat, const uvec2& 图元ID, const S_ColorTake& ct) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_at_Indirect(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	//m_间接Ptr.p变换[id] = mat;
	//m_间接Ptr.p间接[id] = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	//if (层.m_顶点.m_Mem.m_大小) {
	//	m_间接Ptr.p间接[id].firstVertex += 层.m_顶点.m_Mem.m_偏移;
	//}
	//((S_ColorTake*)m_间接Ptr.p颜色)[id] = ct;
}

void ui_绘制模板_画预设图形::f_set纹理属性(uint32 id, const mat3X2& mat, const uvec2& 图元ID, S_TextueProp& texProp) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_纹理属性_at(*m_图元.纹理属性, id) = texProp;
	f_buf_at_Indirect(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	
	//m_间接Ptr.p变换[id] = mat;
	//m_间接Ptr.p间接[id] = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	//if (层.m_顶点.m_Mem.m_大小) {
	//	m_间接Ptr.p间接[id].firstVertex += 层.m_顶点.m_Mem.m_偏移;
	//}
	//((S_TextueProp*)m_间接Ptr.p颜色)[id] = texProp;
}


void ui_绘制模板_画预设图形::f_Close(uint32 num) {
	f_vg_set实例数量(m_画布, m_图元.层, num);
	
	auto& 区间 = m_画布->m_surf[m_图元.层].m_间接;
	for (uint32 i = num; i < 区间.m_Mem.m_大小; ++i) {
		f_buf_Indirect_ptr(区间)[i] = {};
	}
	//f_buf_gresize(m_画布->m_surf[m_图元.层].m_间接, 0);
	//m_画布->m_surf[m_图元.层].m_间接.m_Mem
}









ui_绘制模板_图标::ui_绘制模板_图标() {
	m_ID = {};
	m_Prt = {};
}

ui_绘制模板_图标::~ui_绘制模板_图标() {
	if(m_ID.id_变换.m_Buf) f_buf_erase(m_ID.id_变换);
	if(m_ID.id_颜色.m_Buf) f_buf_erase(m_ID.id_颜色);
}

void ui_绘制模板_图标::f_Draw单色(S_2D画布* 画布, uint16 属性ID, std::string ico集) {
	//return;
	m_画布 = 画布;
	f_ui绘制模板_单色图标绘制(m_画布, m_ID, 属性ID, ico集);
}

void ui_绘制模板_图标::f_Draw彩色(S_2D画布* 画布, uint16 属性ID, std::string ico集) {
	//return;
	m_画布 = 画布;
	f_ui绘制模板_图标绘制(m_画布, m_ID, 属性ID, ico集);
}

void ui_绘制模板_图标::f_alloc(uint32 num) {
	f_buf_gresize(m_ID.id_变换, num);
	f_buf_gresize(m_ID.id_颜色, num);


	auto& 层 = m_画布->m_surf[m_ID.层ID];
	层.m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	层.m_实例数量 = m_ID.id_变换.m_Mem.m_大小;
	层.m_顶点偏移 = 层.m_顶点.m_Mem.m_偏移;
	层.m_顶点数量 = 1;

	if (num) {
		m_Prt.pCoord = f_buf_Mat3X2_ptr(m_ID.id_变换);
		m_Prt.pColor = f_buf_UI32_ptr(m_ID.id_颜色);
	}
	else {
		m_Prt = {};
	}
	
}

void ui_绘制模板_图标::f_set(std::string ico, uint32 offset, const mat3X2 mat, const S_RGBA8UI 颜色) {
	assert(offset < m_ID.id_变换.m_Mem.m_大小);
	assert(offset < m_ID.id_颜色.m_Mem.m_大小);
	m_Prt.pCoord[offset] = mat;
	m_Prt.pCoord[offset].row2.x = f_vg_get图标坐标(m_画布, m_ID.层ID, ico);
	m_Prt.pColor[offset] = f_PackData4X8(颜色);
}

void ui_绘制模板_图标::f_Close() {
	//return;
	f_vg_set实例数量(m_画布, m_ID.层ID, 0);
}







ui_绘制模板_刻度线::ui_绘制模板_刻度线() {
	m_Mat = nullptr;
	m_线Color = nullptr;

	m_间隔比例 = { 20,20 };
	m_ID = {};
}

ui_绘制模板_刻度线::~ui_绘制模板_刻度线() {
	if(m_ID.id_变换.m_Buf) f_buf_erase(m_ID.id_变换);
	if(m_ID.id_颜色.m_Buf) f_buf_erase(m_ID.id_颜色);
}

void ui_绘制模板_刻度线::f_Draw(S_2D画布* 画布, uint16 属性ID) {
	m_画布 = 画布;

	m_ID.id_变换 = f_buf_alloc(S_2D画布::g图标变换, 1);
	m_ID.id_颜色 = f_buf_alloc(S_2D画布::g图标颜色, 1);
	
	m_ID.层ID = f_vg_gen刻度线(画布, 属性ID, 1.0);

}

void ui_绘制模板_刻度线::f_Draw网格(S_2D画布* 画布, uint16 属性ID) {
	m_画布 = 画布;

	m_ID.id_变换 = f_buf_alloc(S_2D画布::g图标变换, 1);
	m_ID.id_颜色 = f_buf_alloc(S_2D画布::g图标颜色, 1);
	
	m_ID.层ID = f_vg_画网格刻度线(画布, 属性ID, 1.0);
}

void ui_绘制模板_刻度线::f_alloc(uint32 num) {
	f_vg_set实例数量(m_画布, m_ID.层ID, num);
	if (!num) return;
	
	m_Mat = f_buf_Mat3X2_ptr(m_ID.id_变换);
	m_线Color = f_buf_UI32_ptr(m_ID.id_颜色);

	//m_画布->m_surf[m_ID.id_元素].m_顶点偏移 = 0;
	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_大小;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = m_ID.id_变换.m_Mem.m_大小;
	//m_画布->m_surf[m_ID.层ID].m_顶点偏移;
	//m_画布->m_surf[m_ID.层ID].m_顶点数量;
}

void ui_绘制模板_刻度线::f_set(uint32 线num, const mat3X2 mat, S_RGBA8UI 颜色, uint32 offset) {
	f_vg_set顶点数量(m_画布, m_ID.层ID, 线num);

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	//m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_大小;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = m_ID.id_变换.m_Mem.m_大小;

	m_Mat[offset] = mat;
	m_线Color[offset] = f_PackData4X8(颜色);
}

void ui_绘制模板_刻度线::f_set(uint32 offset, uint32 线num, const mat3X2 mat, S_RGBA8UI 颜色) {
	f_vg_set顶点数量(m_画布, m_ID.层ID, 线num);

	m_Mat[offset] = mat;
	m_线Color[offset] = f_PackData4X8(颜色);
}







ui_绘制模板_块文本绘制::ui_绘制模板_块文本绘制() {
}

void ui_绘制模板_块文本绘制::f_Draw点(S_2D画布* 画布, uint16 字号, const S_Font& 字体, uint16 属性ID) {
	//============================ 选择焦点背景 =============================
	{
		//f_ui绘制模板_凸边矩形绘制(画布, m_选取ID, 属性ID);
	}


	//m_文本.id_变换 = f_vg_gen变换(画布, 0);
	//m_文本.id_颜色 = f_vg_gen颜色(画布, 0);
	m_文本.id_文本 = f_vg_gen文本ID(画布);
	m_文本.笔刷 = f_vg_gen文本块笔刷(画布, m_文本.id_变换, m_文本.id_颜色, 属性ID, 字体);
	//m_文本.笔刷 = f_vg_gen文本笔刷(画布, m_文本.id_变换, m_文本.id_颜色, 属性ID, m_文本.id_文本, 字体名称, 字号);
	m_文本.id_元素 = f_vg_画文本(画布, m_文本.笔刷);

	//m_文本.文字tex = 画布->m_调色板->m_Fonts[m_文本.笔刷.m_纹理库对象];
	//f_ui绘制模板_文本绘制(画布, m_行号, 属性ID, 字体);


	//============================ 编辑框光标 ===============================
	{
		std::vector<vec2> point = { {0,0}, {0,1} };
		//f_ui绘制模板_单色线(画布, m_光标ID.id_变换, m_光标ID.id_颜色, m_光标ID.id_元素, 属性ID);
		//f_vg_set单色(画布, m_光标ID.id_颜色, 0, S_UI主题::uic_菜单焦点色);
	}

}

S_sf_文字GPU参数映射 ui_绘制模板_块文本绘制::f_GPU参数修改_begin(S_2D画布* 画布, uint32 num, uint32 行) {
	bool GPU参数重新配置 = false;

	GPU参数重新配置 |= f_vg_resize参数实例(画布, m_文本.id_变换, num);
	GPU参数重新配置 |= f_vg_resize参数实例(画布, m_文本.id_颜色, num);

	GPU参数重新配置 |= f_ui绘制模板_resize文本变换(画布, m_行号, 行*5);


	f_vg_set实例数量(画布, m_文本.id_元素, num);
	f_vg_set实例数量(画布, m_行号.id_元素, 行*5);


	

	//m_映射指针.coord = f_vg_map变换(画布, m_文本.id_变换);
	//m_映射指针.color = f_vg_map单色(画布, m_文本.id_颜色);
	m_映射指针.GPU参数重置 = GPU参数重新配置;

	//m_行号映射指针 = f_ui绘制模板_map参数指针(画布, m_行号);

	return m_映射指针;
}

void ui_绘制模板_块文本绘制::f_填充文本(S_2D画布* 画布, std::wstring txt, const S_RGBA8UI& color, vec2 pos, uint32 offset)
{
	//f_vg_set文本段(画布, m_文本对象, txt, offset);

	auto& 字体 = 画布->m_调色板->m_Fonts[画布->m_surf[m_文本.id_元素].m_纹理];
	for (auto e : txt) {
		m_映射指针.coord[offset].row0 = pos;
		m_映射指针.coord[offset].row1 = { 1,1 };
		//m_映射指针.coord[offset].row2.x = 字体.f_从外部编码取内部编码(e);
		m_映射指针.coord[offset].row2.x = e;
		m_映射指针.coord[offset].row2.y = 0;

		m_映射指针.color[offset] = f_PackData4X8(color);

		pos.x += 字体.f_get字符宽度(e) + S_UI主题::ui_文字间隔;
		++offset;
	}
	//f_vg_set单色(画布, m_文本.id_颜色, offset, color);

	f_vg_set实例数量(画布, m_文本.id_元素, txt.size());
}

void ui_绘制模板_块文本绘制::f_填充文本(S_2D画布* 画布, const S_文档文本& txt, vec2 pos, const S_Font& 字体, int16 行距) {
	uint32 offset = 0;
	vec2 左边顶边 = pos;
	左边顶边.y += 0.5 * 行距;
	//
	uint32 行数量 = txt.m_文本块.size();
	for (uint32 y = 0; y < 行数量; ++y) {
		uint32 num = txt.m_文本块[y].size();

		auto* t = txt.m_文本块[y].data();
		auto* c = txt.m_Color[y].data();
		//float32 左边 = 0;
		for (uint32 i = 0; i < num; ++i) {
			uint32 id = offset + i;
			m_映射指针.coord[id].row0 = 左边顶边;
			m_映射指针.coord[id].row1 = { 1,1 };
			//m_映射指针.coord[id].row2.x = 字体.f_从外部编码取内部编码(t[i]);
			m_映射指针.coord[id].row2.x = t[i];
			m_映射指针.coord[id].row2.y = 0;


			m_映射指针.color[id] = f_PackData4X8(c[i]);


			if (t[i] == '\t') {
				左边顶边.x += 字体.m_字号*2 + S_UI主题::ui_文字间隔;
			}
			else {
				左边顶边.x += 字体.f_get字符宽度(t[i]) + S_UI主题::ui_文字间隔;
			}

		}


		uint32 行号GPU偏移 = y * 5;
		auto 行号文本 = f_整数值转宽字符串(y);
		uint8 行号文本数量 = 行号文本.size();
		float32 行号左边 = 0;
		for (uint8 i = 0; i < 行号文本数量; ++i) {
			m_行号映射指针.coord[行号GPU偏移].row0 = { 行号左边, 左边顶边.y };
			m_行号映射指针.coord[行号GPU偏移].row1 = { 1,1 };
			//m_行号映射指针.coord[行号GPU偏移].row2.x = 字体.f_从外部编码取内部编码(行号文本[i]);
			m_行号映射指针.coord[行号GPU偏移].row2.x = 行号文本[i];
			m_行号映射指针.coord[行号GPU偏移].row2.y = 0;
			m_行号映射指针.color[行号GPU偏移] = f_PackData4X8(S_UI主题::uic_编辑框行号);

			行号左边 += 字体.f_get字符宽度(行号文本[i]) + S_UI主题::ui_文字间隔;
			++行号GPU偏移;
		}
		

		offset += num;
		左边顶边.x = pos.x;
		左边顶边.y += 字体.m_字号 + 行距;
	}
	//for (uint32 y = 0; y < 行数量; ++y) {
	//	offset += txt.m_文本块[y].size();
	//}
	f_vg_set实例数量(画布, m_文本.id_元素, offset);
}

void ui_绘制模板_块文本绘制::f_GPU参数修改_end(S_2D画布* 画布)
{
	f_vg_unmapGPU参数(画布, m_文本.id_变换);
	f_vg_unmapGPU参数(画布, m_文本.id_颜色);

	f_ui绘制模板_unmap参数指针(画布, m_行号);

	m_映射指针 = { nullptr, nullptr };
	m_行号映射指针 = {};
}

void ui_绘制模板_块文本绘制::f_开启编辑(S_2D画布* 画布, C_Widget* w) {
	

}

void ui_绘制模板_块文本绘制::f_输入(S_2D画布* 画布, C_文本框* box, std::wstring& text) {
	mat3X2 editBoxMat;

	editBoxMat.row0 = box->g_光标绘制位置;
	editBoxMat.row1 = {1, 20};
	editBoxMat.row2 = { 1, 0 };
	f_vg_set变换(画布, m_光标ID.id_变换, 0, editBoxMat);

	f_vg_set实例数量(画布, m_光标ID.id_元素, 1);
}

void ui_绘制模板_块文本绘制::f_输入完成(S_2D画布* 画布, C_文本框* box) {
	mat3X2 editBoxMat;

	editBoxMat.row0 = box->g_光标绘制位置;
	editBoxMat.row1 = { 1, 20 };
	editBoxMat.row2 = { 1, 0 };
	f_vg_set变换(画布, m_光标ID.id_变换, 0, editBoxMat);

	f_vg_set实例数量(画布, m_光标ID.id_元素, 1);
}

void ui_绘制模板_块文本绘制::f_框选(S_2D画布* 画布, C_文本框* box) {
	return;
	bool GPU参数重新配置 = f_ui绘制模板_重置凸矩形数量(画布, m_选取ID, box->m_文档->m_文本块.size());


	int32 行数 = box->m_选取.结束行列.y - box->m_选取.开始行列.y;
	int32 开始行 = box->m_选取.开始行列.y;



	int32 起始列;
	int32 结束列;
	if (行数 < 0) {
		行数 = abs(行数);
		开始行 = box->m_选取.结束行列.y;
		//结束列 = box->m_选取.开始行列.x;
		//起始列 = box->m_选取.结束行列.x;
	}
	else {
		//起始列 = box->m_选取.开始行列.x;
		//结束列 = box->m_选取.结束行列.x;
	}

	//std::cout << "列 = " << box->m_选取.结束行列.x << " : " << box->m_选取.开始行列.x << std::endl;
	if (!(box->m_选取.结束行列.x - box->m_选取.开始行列.x) && !行数) {
		f_vg_set实例数量(画布, m_选取ID.id_元素, 0);
		return;
	}

	f_vg_set实例数量(画布, m_选取ID.id_元素, 行数+1);
	
	
	//float32 推进 = box->m_文本边偏移.x;
	vec2 viewOffset = box->m_Pos;

	
	f_vg_set实例数量(画布, m_光标ID.id_元素, 0);
}













ui_绘制模板_曲线::ui_绘制模板_曲线() {
	m_曲线点 = nullptr;
	m_曲线ID = nullptr;

	m_曲线点Ptr = nullptr;
	m_点元素 = 0;
	m_点数量 = 0;
}

void ui_绘制模板_曲线::f_Draw控制点(S_2D画布* 画布, uint16 属性ID) {
	m_画布 = 画布;
	if(!m_曲线点) m_曲线点 = f_vg_gen曲线(m_画布);
	//assert(m_曲线ID);
	m_点元素 = f_vg_画曲线点(m_画布, 属性ID, m_曲线点);
}

void ui_绘制模板_曲线::f_Draw(S_2D画布* 画布, uint16 属性ID, bool 多曲线) {
	m_画布 = 画布;

	if (!m_曲线点) m_曲线点 = f_vg_gen曲线(m_画布);
	//m_曲线ID = f_vg_gen曲线点索引(m_画布);
	m_线元素 = f_vg_画曲线(m_画布, 属性ID, m_曲线点, 1.2, 多曲线);
}


void ui_绘制模板_曲线::f_begin(uint32 线段区数量) {
	if (m_点元素) {
		m_画布->m_surf[m_点元素].m_实例数量 = 线段区数量;
	}

	if (!线段区数量) {
		m_画布->m_surf[m_线元素].m_实例数量 = 0;
		return;
	}

	f_resize板载缓存_Up(m_曲线点, 线段区数量);
	//f_resize板载缓存_Up(m_曲线ID, 线段区数量);
	m_画布->m_surf[m_线元素].m_实例数量 = 线段区数量 - 1;
	m_曲线点Ptr = f_vg_map曲线坐标(m_曲线点);
	
	m_点数量 = 线段区数量;
}

void ui_绘制模板_曲线::f_end() {
	if (m_曲线点Ptr) {
		m_曲线点->f_unmap();
	}
	m_曲线点Ptr = nullptr;
}

void ui_绘制模板_曲线::f_setPoint(uint32 offset, const S_CurvePoint& 曲线点) {

	m_曲线点Ptr[offset] = 曲线点;
	//m_曲线IDPtr[offset] = id;
}

void ui_绘制模板_曲线::f_setPointColor(uint32 offset, const uint32 color) {
	m_曲线点Ptr[offset].ID_Color.y = color;
}

void ui_绘制模板_曲线::f_setPointColor(uint32 offset, const S_RGBA8UI& color) {
	m_曲线点Ptr[offset].ID_Color.y = f_PackData4X8(color);
}

void ui_绘制模板_曲线::f_setPointSelect(uint32 offset, uint32 b) {
	m_曲线点Ptr[offset].Select_Type.x = b;
}

void ui_绘制模板_曲线::f_setPointType(uint32 offset, uint32 b) {
	m_曲线点Ptr[offset].Select_Type.y = b;
}

void ui_绘制模板_曲线::f_setLine(uint32 offset, uint16 left_id, uint16 rigth_id) {
	//m_曲线IDPtr[offset] = uint32(left_id)<<16 | rigth_id;
	//m_IndirectPrt[dim.y].vertexCount = 1;
	//m_IndirectPrt[dim.y].instanceCount = dim.x;
	//m_IndirectPrt[dim.y].instanceCount = m_Dim.x;
	//m_IndirectPrt[dim.y].firstVertex = 0;
	//m_IndirectPrt[dim.y].firstInstance = dim.y * m_Dim.x;
}

void ui_绘制模板_曲线::f_插入点(const S_CurvePoint& 曲线点, const S_RGBA8UI& color, uint32 链接ID, uint64 offset) {
	uint32 c = f_PackData4X8(color);
	f_buf_insert(m_曲线点, offset, &曲线点, 1);
	//f_buf_insert(m_曲线ID, offset, &链接ID, 1);
}

void ui_绘制模板_曲线::f_map() {
	m_曲线点Ptr = f_vg_map曲线坐标(m_曲线点);
}

void ui_绘制模板_曲线::f_unmap() {
	m_曲线点->f_unmap();
	m_曲线点Ptr = nullptr;
}













ui_绘制模板_自定义线::ui_绘制模板_自定义线() {
	m_画布 = nullptr;
	m_Prt = {};
	m_ID = {};
	m_NextID = 0;
}

ui_绘制模板_自定义线::~ui_绘制模板_自定义线() {
	if(m_ID.id_变换.m_Buf) f_buf_erase(m_ID.id_变换);
	if(m_ID.id_颜色.m_Buf) f_buf_erase(m_ID.id_颜色);

	m_ID.id_变换 = {};
	m_ID.id_颜色 = {};
}

void ui_绘制模板_自定义线::f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷) {
	m_画布 = 画布;
	
	switch (笔刷) {
	case e_圆公切链接线:
		break;
	default:
		f_ui绘制模板_动态线(m_画布, m_ID, 属性ID, 2.0);
		break;
	}
	
	//f_vg_set绘制线(m_画布, m_ID.层ID, 1, {});

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = 0;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = 0;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = 0;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = 0;
}

void ui_绘制模板_自定义线::f_alloc(uint32 num, const S_RGBA8UI& C) {
	f_buf_gresize(m_画布->m_surf[m_ID.层ID].m_顶点, num);

	f_buf_gresize(m_ID.id_变换, 1);
	f_buf_gresize(m_ID.id_颜色, 1);
	m_NextID = 0;

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = num;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = m_ID.id_变换.m_Mem.m_大小;

	f_buf_Mat3X2_at(m_ID.id_变换, 0) = {{},{1,1}, {}};
	f_buf_UI32_at(m_ID.id_颜色, 0) = f_PackData4X8(C);
}

void ui_绘制模板_自定义线::f_End() {
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_NextID;
}

void ui_绘制模板_自定义线::f_set下一个顶点(const vec2& pos, const S_RGBA8UI& C) {
	//return;
	f_vg_set绘制线(m_画布, m_ID.层ID, m_NextID, pos);
	++m_NextID;

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_NextID;

}

void ui_绘制模板_自定义线::f_set顶点(uint32 id, const vec2& pos) {
	if (m_画布) {
		f_vg_set绘制线(m_画布, m_ID.层ID, id, pos);

		m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
		m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_大小;
	}
}

void ui_绘制模板_自定义线::f_set顶点(uint32 id, const vec2& pos, const S_RGBA8UI& C) {
	f_vg_set绘制线(m_画布, m_ID.层ID, id, pos);

	f_buf_UI32_at(m_ID.id_颜色, id) = f_PackData4X8(C);
}

void ui_绘制模板_自定义线::f_Close(uint32 num) {
	//return;
	lines.clear();
	m_NextID = num;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = num;
}

void ui_绘制模板_自定义线::f_get线坐标() {
	//return;
	if (m_NextID) {
		lines.resize(m_NextID);

		S_2D图元顶点* points = f_buf_图元顶点_ptr(m_画布->m_surf[m_ID.层ID].m_顶点);

		for (uint32 i = 0; i < m_NextID; ++i) {
			lines[i] = points[i].coord;
		}
	}
}





ui_绘制模板_渐变::ui_绘制模板_渐变() {

}

void ui_绘制模板_渐变::f_Draw(S_2D画布* 画布, S_渐变图元 图元属性, E_方向 方向){
	m_画布 = 画布;
	m_方向 = 方向;
	m_图元 = f_vg_gen渐变图元(m_画布, 图元属性);
	//f_vg_画渐变(m_画布, m_图元);
}

void ui_绘制模板_渐变::f_alloc(uint32 num, const std::vector<vec4>& cp) {
	S_ColorGradient 渐变;
	渐变.take_r = 0;
	渐变.take_g = 0;
	渐变.take_b = 0;
	渐变.take_b = 0;
	渐变.controlPointNum = DEF_Max(cp.size(), 2);
	渐变.dir = m_方向;
	//f_buf_set(m_图元.渐变, 0, 渐变);
	f_buf_渐变属性_at(*m_图元.渐变, 0) = 渐变;

	//f_resize板载缓存_Up(m_图元.颜色, 渐变.controlPointNum);
	//f_buf_fill(m_图元.颜色, cp.data(), cp.size());
	f_buf_gresize(*m_图元.颜色, 渐变.controlPointNum);
	f_gbuf_fill(*m_图元.颜色, cp.data(), 0, cp.size());

	//f_resize板载缓存_Up(m_图元.变换, num);
	//f_resize板载缓存_Up(m_图元.渐变, num);
	f_buf_gresize(*m_图元.变换, num);
	f_buf_gresize(*m_图元.渐变, num);
	f_vg_resize间接参数(m_画布, m_图元.层, num);

	f_vg_set实例数量(m_画布, m_图元.层, num);
}

void ui_绘制模板_渐变::f_End() {

}

void ui_绘制模板_渐变::f_填充渐变点(uint32 id, const mat3X2 mat, const uvec2& 图元ID) {
	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	m_画布->m_surf[m_图元.层].m_顶点偏移 = 图元ID.x;
	m_画布->m_surf[m_图元.层].m_顶点数量 = 图元ID.y - 图元ID.x;
	m_画布->m_surf[m_图元.层].m_实例偏移 = m_图元.变换->m_Mem.m_偏移 + id;
	m_画布->m_surf[m_图元.层].m_实例数量 = 1;
	//f_buf_Indirect_ptr(m_画布->m_surf[m_图元.层].m_间接)[id] = S_VkDrawIndirectCommand{ 图元ID.y - 图元ID.x, 1, 图元ID.x, id };
}

void ui_绘制模板_渐变::f_Close(uint32 num) {

}





ui_绘制模板_表格::ui_绘制模板_表格() {
	m_画布 = nullptr;
	m_层 = 0;
	m_大小 = {60,20};
}

ui_绘制模板_表格::~ui_绘制模板_表格() {
	if(m_表格线.m_Buf) f_buf_erase(m_表格线);
	if(m_颜色.m_Buf) f_buf_erase(m_颜色);
}

void ui_绘制模板_表格::f_Draw(S_2D画布 * 画布, uint16 属性ID) {
	m_画布 = 画布;

	m_表格线 = f_buf_alloc(m_画布->g表格变换GPU缓存, 1);
	m_颜色 = f_buf_alloc(m_画布->g表格颜色GPU缓存, 1);

	m_层 = f_vg_画表格(画布, 画布->m_属性[属性ID]);

}

void ui_绘制模板_表格::f_fill(uint32 hNum, uint32 vNum) {
	uint32 num = DEF_Max(hNum, 1) * DEF_Max(vNum, 1);
	f_buf_gresize(m_表格线, num);
	f_buf_gresize(m_颜色, num);
	
	m_画布->m_surf[m_层].m_实例偏移 = m_表格线.m_Mem.m_偏移;
	m_画布->m_surf[m_层].m_实例数量 = m_表格线.m_Mem.m_大小;

	vec2* 线指针 = f_buf_Vec2_ptr(m_表格线);
	uint32* 颜色指针 = f_buf_UI32_ptr(m_颜色);
	for (uint32 y = 0; y < vNum; ++y) {
		for (uint32 x = 0; x < hNum; ++x) {
			uint32 index = y*hNum + x;
			线指针[index] = { m_大小.x * x, m_大小.y * y };
			颜色指针[index] = f_PackData4X8({50,50,50,255});
		}
	}
}

void ui_绘制模板_表格::f_Close(uint32 num) {
	m_画布->m_surf[m_层].m_实例数量 = num;
}





ui_绘制模板_2D矢量图形::ui_绘制模板_2D矢量图形() {
	m_变换 = {};
	m_颜色 = {};
}
ui_绘制模板_2D矢量图形::~ui_绘制模板_2D矢量图形() {
	f_buf_erase(m_变换);
	f_buf_erase(m_颜色);
}

void ui_绘制模板_2D矢量图形::f_Draw(S_2D画布* 画布, uint16 属性ID, bool 填充) {
	m_画布 = 画布;

	m_层 = f_vg_画矢量线(m_画布,  m_画布->m_属性[属性ID]);
	m_颜色 = f_buf_alloc(m_画布->g表格颜色GPU缓存, 1);
	m_变换 = f_buf_alloc(m_画布->g变换GPU缓存, 1);

	m_画布->m_surf[m_层].m_顶点 = f_buf_alloc(m_画布->g顶点, 1);
	m_画布->m_surf[m_层].m_索引 = f_buf_alloc(m_画布->g索引, 1);
}

void ui_绘制模板_2D矢量图形::f_fill(const mat3X2 mat, std::vector<vec2>& 顶点坐标, std::vector<uint32>& 顶点索引) {
	uint32 vNum = 顶点坐标.size();
	uint32 iNum = 顶点索引.size();
	f_buf_gresize(m_画布->m_surf[m_层].m_顶点, vNum);
	f_buf_gresize(m_画布->m_surf[m_层].m_索引, iNum);

	if (vNum && iNum) {
		f_gbuf_fill(m_画布->m_surf[m_层].m_索引, 顶点索引.data(), 0, iNum);

		auto* 图元 = f_buf_图元顶点_ptr(m_画布->m_surf[m_层].m_顶点);
		for (uint32 i = 0; i < vNum; ++i) {
			图元[i].coord = 顶点坐标[i];
		}

		m_画布->m_surf[m_层].m_实例数量 = 1;
		m_画布->m_surf[m_层].m_顶点数量 = vNum;
		m_画布->m_surf[m_层].m_顶点偏移 = m_画布->m_surf[m_层].m_顶点.m_Mem.m_偏移;
	}
	else {
		m_画布->m_surf[m_层].m_实例数量 = 0;
		m_画布->m_surf[m_层].m_顶点数量 = 0;
		m_画布->m_surf[m_层].m_顶点偏移 = 0;
	}

	
}

void ui_绘制模板_2D矢量图形::f_Close(uint32 num) {
	m_画布->m_surf[m_层].m_实例数量 = num;
}




ui_绘制模板_纹理::ui_绘制模板_纹理() {
	m_画布 = nullptr;
	m_纹理变换 = {};
	m_纹理属性 = {};
}

ui_绘制模板_纹理::~ui_绘制模板_纹理() {
	f_buf_erase(m_纹理变换);
	f_buf_erase(m_纹理属性);
}

void ui_绘制模板_纹理::f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷, S_纹理* 纹理) {
	m_画布 = 画布;
	
	m_纹理变换 = f_buf_alloc(S_2D画布::g纹理变换, 1);
	m_纹理属性 = f_buf_alloc(S_2D画布::g纹理属性, 1);
	
	switch (笔刷) {
	case e_单色纹理:
		break;
	case e_纹理:
		m_层ID = f_vg_画纹理(m_画布, 属性ID, 纹理);
		break;
	case e_条纹:
		break;
	case e_色轮:
		break;
	case e_渐变:
		break;
	case e_噪波:
		m_层ID = f_vg_画噪波(m_画布, 属性ID);
		break;
	default:
		break;
	}
	
	auto& 层 = m_画布->m_surf[m_层ID];
	层.m_间接 = f_buf_alloc(S_2D画布::g间接, 1);
	层.m_实例数量 = 1;
	层.m_顶点数量 = 0;
	层.m_顶点偏移 = 0;
}

void ui_绘制模板_纹理::f_alloc(uint32 num) {
	auto& 层 = m_画布->m_surf[m_层ID];

	f_buf_gresize(m_纹理变换, num);
	f_buf_gresize(m_纹理属性, num);
	f_buf_gresize(层.m_间接, num);

	层.m_实例数量 = m_纹理变换.m_Mem.m_大小;
	层.m_实例偏移 = m_纹理变换.m_Mem.m_偏移;
}

void ui_绘制模板_纹理::f_set(uint32 id, const mat3X2& mat, const uvec2& 图元ID, const S_RGBA8UI& C, const S_TextueProp& texProp) {
	auto& 层 = m_画布->m_surf[m_层ID];

	f_buf_Mat3X2_at(m_纹理变换, id) = mat;
	f_buf_at_Indirect(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_纹理变换.m_Mem.m_偏移) };
	f_buf_纹理属性_at(m_纹理属性, id) = texProp;

	//层.m_顶点数量 = 层.m_顶点.m_Mem.m_大小;
	//层.m_顶点偏移 = 层.m_顶点.m_Mem.m_偏移;
}

void ui_绘制模板_纹理::f_绑定纹理(S_纹理* text, uint32 id, const S_RGBA8UI& C) {
	auto& 层 = m_画布->m_surf[m_层ID];

	层.m_笔刷.m_纹理参数[id] = text;
	层.m_笔刷.m_纹理参数数量 = 1;
}

void ui_绘制模板_纹理::f_Close(uint32 num) {
	m_画布->m_surf[m_层ID].m_实例数量 = num;
}





ui_绘制模板_线段::ui_绘制模板_线段() {
	m_画布 = nullptr;
	m_线段数据 = {};
	m_层ID = 0;
}

ui_绘制模板_线段::~ui_绘制模板_线段() {
}

void ui_绘制模板_线段::f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷) {
	m_画布 = 画布;
	switch (笔刷) {
	case E_笔刷类型::e_圆公切链接线:
		m_层ID = f_vg_画园公切线链接线(m_画布, 属性ID, 1.0);

		m_线段数据 = f_buf_alloc(S_2D画布::g线段, 0);
		return;
	}
}

void ui_绘制模板_线段::f_alloc(uint32 num) {
	f_buf_gresize(m_线段数据, num);

	auto& 层 = m_画布->m_surf[m_层ID];

	层.m_顶点数量 = 1;
	层.m_顶点偏移 = 0;

	层.m_实例数量 = num;
	层.m_实例偏移 = m_线段数据.m_Mem.m_偏移;
}

void ui_绘制模板_线段::f_set(uint32 id, const S_CurvePoint& point) {
	f_buf_曲线段_at(m_线段数据, id) = point;
}

void ui_绘制模板_线段::f_Close(uint32 num) {
	auto& 层 = m_画布->m_surf[m_层ID];
	层.m_实例数量 = 0;
}









//void f_ui绘制模板_边面凸边矩形绘制(S_2D画布* s, S_单色边面ID& id, uint16 属性ID, float32 线宽) {
//	id.id_图元 = f_vg_gen图元(s, 1);
//	id.id_变换 = f_vg_gen变换(s, 1);
//	id.id_面颜色 = f_vg_gen颜色(s, 1);
//	id.id_边颜色 = f_vg_gen颜色(s, 1);
//
//	id.id_边元素 = f_vg_gen单色凸边形描边(s, id.id_图元, id.id_变换, id.id_边颜色, 属性ID, 线宽);
//	id.id_面元素 = f_vg_gen单色凸边形填充(s, id.id_图元, id.id_变换, id.id_面颜色, 属性ID);
//}

//void f_ui绘制模板_凸边线绘制(S_2D画布* s, S_单色绘制ID& id, uint16 属性ID) {
//	id.id_图元 = f_vg_gen图元(s, 1);
//	id.id_变换 = f_vg_gen变换(s, 1);
//	id.id_颜色 = f_vg_gen颜色(s, 1);
//	id.id_元素 = f_vg_gen单色凸边形描边(s, id.id_图元, id.id_变换, id.id_颜色, 属性ID);
//}

//void f_ui绘制模板_纹理面绘制(S_2D画布* s, S_单色绘制ID& id, uint16 属性ID, E_笔刷类型 笔刷类型) {
//	id.id_图元 = f_vg_gen图元(s, 1);
//	id.id_变换 = f_vg_gen变换(s, 1);
//	id.id_颜色 = f_vg_gen2颜色(s);
//
//	id.id_元素 = f_vg_gen填充凸边形(s, id.id_图元, id.id_变换, id.id_颜色, 属性ID, 笔刷类型);
//}

//void f_ui绘制模板_单色线(S_2D画布* s, S_单色绘制ID& ID, uint16 属性ID) {
//	ID.id_变换 = f_vg_gen变换(s);
//	ID.id_颜色 = f_vg_gen颜色(s);
//	ID.id_图元 = f_vg_gen图元(s, 1);
//	ID.id_元素 = f_vg_gen单色描边(s, ID.id_图元, ID.id_变换, ID.id_颜色, 属性ID);
//}


//void f_ui绘制模板_无边圆角矩形(S_2D画布* s, uint16& 变换ID, uint16& 颜色ID, uint16& 元素ID, uint16 属性ID) {
//	变换ID = f_vg_gen变换(s);
//	颜色ID = f_vg_gen颜色(s);
//
//	auto pen = f_vg_gen单色填充(s, 变换ID, 颜色ID, 属性ID);
//	
//	f_vg_set单色(s, 颜色ID, 0, S_UI主题::uic_按钮);
//	//元素ID = f_vg_绘制圆角矩形(s, pen, { 0.0f, 0.0f, 1.0f, 1.0f }, S_UI主题::ui_面板圆角半径, true);
//	元素ID = f_vg_绘制圆角矩形(s, pen, true, S_UI主题::ui_面板圆角半径);
//	//f_vg_set实例数量(s, g面板绘制元素ID, 1);
//}

//void f_ui绘制模板_编辑文本(S_2D画布* s, uint16& 文字ID, uint16& 变换ID, uint16& 颜色ID, uint16& 元素ID, uint16 属性ID, S_2D文本对象& tObj, uint16 字号) {
//	颜色ID = f_vg_gen颜色(s, 0);
//	变换ID = f_vg_gen变换(s, 0);
//	文字ID = f_vg_gen文本ID(s);
//
//	tObj = f_vg_gen文本笔刷(s, 变换ID, 颜色ID, 属性ID, 文字ID, S_UI主题::ui_默认字体, 字号);
//	元素ID = f_vg_画文本(s, *tObj.字体笔刷);
//}
//
//
//void f_ui绘制模板_画行文本(S_2D画布* s, S_单色文本绘制ID& 文本ID, uint16 属性ID, uint16 字号) {
//	文本ID.id_变换 = f_vg_gen变换(s, 0);
//	文本ID.id_颜色 = f_vg_gen颜色(s, 0);
//	文本ID.id_文本 = f_vg_gen文本ID(s);
//
//	文本ID.id_元素 = f_vg_画行文本(s, 文本ID.id_文本, 文本ID.id_变换, 文本ID.id_颜色, 属性ID, 字号, S_UI主题::ui_默认字体);
//}

